Skip to main content

Full text of "Systèmes Embarqués Chapitre 3"

See other formats


i uLtUI | Lj. nl jifill LLlII ÉJUjLtJI 

Etoli Supiriiun ia Tichn«l«gl« «l d'htorirmliqii» 



Module: Systèmes Embarqués 
Chapitre 3: 

Les Processeurs ARM 

El Kefi HLEL 
Février 2014 



Marché de l'Embarqué 



35% increase in ARM embedded process or core adoption! 




Présentation d'ARM 




Présentation des Processeurs ARM 



o Les architectures ARM, développées par ARM Ltd (Advanced Risc 

Machine Limited), sont des architectures RISC 32 bits (ARMv3 à ARMv7) et 
64 bits (ARMv8) 

o Une particularité des processeurs ARM est leur mode de vente. En effet, 
ARM Ltd ne fabrique ni ne vend ses processeurs sous forme de circuits 
intégrés 

o La société vend les licences de ses processeurs de manière à ce qu'ils soient 
gravés dans le silicium par d'autres fabricants. Aujourd'hui, la plupart des 
grands fondeurs de puces proposent de l'architecture ARM 

o De nombreux systèmes d'exploitation sont compatibles avec cette 
architecture : 

• Symbian S60 avec les Nokia N97 ou Samsung Player HD 

• iOS avec l'iPhone et HPad 

• Linux, avec la plupart des distributions ou avec Android 
BlackBerry OS avec les BlackBerry 

• Windows CE, Windows Phone 7 et Windows RT, une version de Windows 8 




Architectures des Processeurs ARM 



Architecture 


Famille(s) 


ARMvl 


ARM1 


ARMv2 


ARM2, ARM3 


ARMv3 


ARM6, ARM 7 


ARMv4 


StrongARM, ARM7TDMI, ARM8, ARM9TDMI 


ARMv5 


ARM7EJ, ARM9E, ARM10E 


ARMv6 


ARM 11 


ARMv6-M 


ARM Cortex-MO, ARM Cortex-M0+, ARM Cortex-Ml 


ARMv7-A 


ARM Cortex-A (ARM Cortex-A8, ARM Cortex-A9 MPCore, 
ARM Cortex-A5 MPCore ARM Cortex-A7 MPCore 
ARM Cortex-Al2 MPCore, ARM Cortex-Al5 MPCore) 


ARMv7-M 


ARM Cortex-M (ARM Cortex-M3) 


ARMv7-R 


ARM Cortex-R (ARM Cortex-R4, ARM Cortex-R5, ARM Cortex-R7) 


ARMv8 


ARM Cortex-A50 (ARM Cortex-A53, ARM Cortex-A57) 



Les Processeurs Les Plus Populaire 



ARM s'appuie sur de nombreuses architectures différentes afin de toucher un 
maximum de marchés. Ses processeurs les plus livrés en 2012-2013 sont: 



ARM 7: 33% (de livraison) 
ARM9: 19% 
ARM11: 8% 
Cortex-M: 26% 
Cortex-A: 11% 
Cortex-R: 3% 



ARM9 



ARM7 




VFPV2 

Floating point acceleratur 


Jazelle® 

JAVA aecelerator 


m 




ARMV4 


ARMvS 



A RM 11 



Thumb®-2 

(option) 



TrustZone"" 



SIMD 



ARMvG 



Cortex 




VFPv3 



NEON™ 

Advanced SIMD 




Les Familles Les Plus Populaire 

Famille ARM 7 : 

• ARM720T (MMU) 
ARM7TDMI 

• ARM7TDMI-S 

• ARM7EJ-S : DSP et Jazelle 

Famille ARM 9 (5 niveaux de pipeline sur les entiers, MMU) : ARM920T (double cache de 16 Ko) 
et ARM922T (double cache de 8 Ko) 

o Famille ARM9E 

• ARM946E-S : DSP, double cache, MPU, 1 port AHB 

• ARM926EJ-S: DSP, double cache, MMU, 2 ports AHB 
ARM966E-S : DSP, double cache, MPU, 1 ports AHB 

o Famille ARM 11 : SIMD, Jazelle, DSP, Thumb-2 
o ARM1136JF-S:FPXJ 

• ARM1156T2-S 

• ARM1 1 56T2F-S : FPU 

• ARM1176JZ-S 

• ARM1 1 76JZF-S : FPU 

Famille Cortex-A, processeur applicatif: Architecture ARMv7-A, SIMD, Jazelle, DSP, Thumb-2 
o Famille Cortex-R, processeur temps-réel: Architecture ARMv7-R 
o Famille Cortex-M, processeur embarqué : Architecture ARMv6-M et ARMv7-M 




Caractéristiques (l) 



Classic 

ARM Proces-sors 



Embedded 

C6 ' tëx P roce?7-5P'T 



Application 

Cortex Processors 




ARM7 



Cnrticîx-riO 



Caractéristiques (2) 




Virtual ization 



Architecture & Jeu d'Instruction (ISA) 



Architecture et Jeu d'Instruction 



o L'architecture ARM est fortement inspirée des principes de conception 
RISC. Elle dispose de 16 registres généraux de 32 bits (de rO à rl5). Les 
instructions codées sur 32 bits jusqu'à l'ARMv7 et sur 64 bits avec l'ARMv8 

o Le jeu d'instruction a reçu des extensions au fil du temps, telles que 

• ARM: c'est le jeu d'instruction par défaut sur 32 bits. Il y a 58 instructions dans 
ce mode et 15 registres + PC 

Thumb : mode instructions sur 16 bits. Permettant d'améliorer la densité du code. 
Il y à 30 instructions et 8 registres disponibles + PC. L'activation de ce mode et 
inversement se fait par l'exécution d'une instruction (respectivement BX et BLX) 

Jazelle : améliorant l'exécution de byte code Java. Il y a un bit (J) dans le CPSR 
(Current Program Status Register) qui indique le mode Jazelle. Les instructions 
sont sur 8 bits 

NEON, supportant des instructions SIMD (Single Instruction Multiple Data) 



O 



Thumb 

o Objectif de thumb: Jeu d'instructions pour la compression de code 

o Moins de registres disponibles (R0-R8) + PC (Program Counter) 

o Thumb est un jeu d'instruction 16 bits pour remplacer un sous-ensemble des 
instructions ARM 32 bits classique et permet un gain important de mémoire 

o Les instructions 16 bits améliorent la densité globale d'un programme, bien 
que certaines opérations nécessitent plus d'instructions. Cela peut réduire le 
temps de chargement du code en mémoire et augmenter la probabilité de 
rester dans le cache d'instruction 

o Le processeur peut commuter entre les 2 modes (16 et 32 bits). Pour garantir 
de la performance, on utilise le jeu d'instruction standard sur 32 bits, et le 
reste Thumb 

o Exemple: dans le cas d'un système embarqué avec une petite quantité de 
RAM accessible via un bus de donnée 32 bits mais la majorité est accédé via 
un second bus de 16 bits. Dans cette situation, il est très intéressant de 
compiler le programme en mode Thumb et d'optimiser les sections les plus 
consommatrices en utilisant le jeu d'instructions complet ARM 32 bits, 
permettant de placer ces instructions plus larges dans le bus d'accès 
mémoire 32 bits 




Thumb-2 



Introduction de nouvelles instructions (130 instructions supplémentaires) pour les 
manipulations de bits 

• Opération d'entrées/sorties 

• Modifications de bits pour des structures temps réel 

Eviter de commuter entre le mode ARM et Thumb, une application peut être écrite 
complètement en Thumb2 (exemple avec Cortex M3) 

Thumb-2 (un jeu d'instructions de largeur variable) comprend: 

• Le jeu d'instructions ARM 32 bits 

• Le jeu d'instructions limité 16 bits de Thumb 

• Un ensemble des instructions 32 bits additionnelles 

Thumb-2 a pour but d'atteindre une densité de code proche de Thumb tout en 
conservant des performances similaires au jeu d'instructions ARM en mémoire 32 bits 



100 
80 
GO 
40 
20 
0 



Relative Dhrystone performance and code size for ARM, Thumb and Thumb-2 

100- 



80 

60 
40 

20 



H 



Thumb-2 Performance 
25% faster than Thumb 



Thumb-2 code size 
26% sma lier than ARM 



□ ARM 
] Thumb-2 
3 Thumb 



© 



Jazelle 



o Jazelle est une technique permettant d'exécuter directement du Bytecode 
Java dans les architectures ARM comme un troisième état d'exécution (et jeu 
d'exécution), en parallèle à l'ARM existant et au mode Thumb (ou Thumb-2) 

o Le support pour cet état est signalé par le « J » dans les architectures 

(ARMv5TEJ) ou dans les noms de cœurs (exemple: ARM9EJ-S et ARM7EJ- 
S) 

o Le bytecode: est un code intermédiaire entre les instructions machines et le 
code source, il n'est pas directement exécutable. Il est produit par un 
compilateur 

o Le bytecode Java: est un bytecode destiné à regrouper des instructions 
exécutables par une machine virtuelle java. Il désigne un flux d'octets 
binaire au format d'une classe java. Ce flux est habituellement le résultat de 
la compilation d'un code source. Ce bytecode peut être exécuté sous de 
nombreux systèmes d'exploitation par une machine virtuelle Java 

e 



Neon: Advanced SIMD 



o Advanced SIMD (Single Instruction Multiple Data) également appelée 
NEON ou ("MPE" pour Media Processing Engine — moteur de calcul de 
médias) combine des jeux d'instructions 64 et 128 bits, qui fournissent de 
l'accélération de calcul standardisé pour les application de médias, 2D/3D et 
de traitement du signal 

o NEON est inclus dans tous les cœurs Cortex-A8 mais est optionnel dans les 
Cortex-A9 

o II comporte 32 registres 64 bits flottants (partagé avec le FPU) pouvant être 
couplés pour former 16 registres de 128 bits flottants, et accepte aussi que 
ces registres soient traités comme des entiers signés ou non signés de 8, 16, 
32 et 64 bits 



Fabricants de Processeurs ARM 



La propriété intellectuelle appartient à une société britannique (ARM Ltd), 
mais les processeurs sont fabriqués sous licence par différentes entreprises. 
Parmi les entreprises fabriquant les modèles des séries Cortex (les plus 
avancées), la majorité se trouve en Asie, suivie par les Etats-Unis et enfin par 
l'Europe: 

• Atmel, Etats-Unis 

Broadcom, Etats-Unis (Cortex A9) 

• Freescale, Etats-Unis 

• Fujitsu, Japon (cortex M3, Cortex A9, A7, Al 5) 

• HiSilicon, Chine (Cortex A9, A7, Al 5) 

• Huawei Technologies, Chine (Cortex A9, A7, Al 5) 
Infineon, Allemagne 

• LG Electronics, Corée du Sud (A50) 
NXP, Pays-Bas 

• Nvidia, États-Unis (Cortex A9) 

• Qualcomm, Etats-Unis 

• Samsung, Corée du Sud (Cortex A8, Cortex A9, A15 (Exynos 5250), A7) 

• STMicroelectronics, France & Italie (Cortex A9, Cortex A15) 

• Texas Instruments, Etats-Unis (Cortex A9, A15) 

• Toshiba, Japon 
Xilinx, États-Unis (FPGA Cortex-A8) 




Exemples 



© 



Exemple: ARMv7 



o ARMv7 

o ARM: 234 instructions 

o SIMD/VFP: 143 instructions 

o Thumb-2: 218 instructions 

o La famille Cortex: Famille de processeurs 
partageants le même Core 32 bits et le même 
jeu d'instruction de base ARMv7 

o Cortex-A: haute performance, faible 
consommation 

o Applications : jeux, communication sans fil, 
routers, multimédia embarqué 

o Cortex-R: applications temps réels 

o Applications : automobile exigeant des 
temps de réponses fixe 

o Cortex-M: applications microcontrôleurs, 
plus de fonctionnalités ou variés 




Pipeline 8 
étages 



Minuterie 



[ Cache 



Contrôleur 
dlnterrupttons 



Unité de gestion 
mémoire 



Bus AXl 



Etude de l'Architecture ARM 7 



rO 




r8 


rl 




r9 


r2 




rlO 


r3 




rll 


r4 




rl2 


r5 




rl3 


r6 




rl4 


r7 




rl5 (PC) 



31 



0 




NZC V 

CPSR : Current program status register 



o N (Négative), Z (Zéro), C (Carry), V (oVerflow) 
o mode - control processor mode 
o T - control instruction set 

• T = 1 - instruction stream is 16-bit Thumb instructions 
T = 0 - instruction stream is 32 -bit ARM instructions 
o I F — interrupt enables 



31 



28 27 



8 7 6 5 4 



E 



NZC V 



unused 



I F 



T 



mode 



Instructions (En Assembleur) 



o Basic format: 
ADD r0,rl,r2 

• Computes rl+r2, stores in rO 
Immédiate operand: 

ADD r0,rl,#2 

• Computes rl+2, stores in rO 
o ADD, ADC : add (w. carry) 

o SUB, SBC : subtract (w. carry) 
o RSB, RSC : reverse sub tract (w. carry) 
o MUL, MLA : multiply (and accumulate) 
o AND, ORR,EOR 

BIC : bit clear 
o LSL, LSR : logical shift left/right 
o ASL, ASR : arithmetic shift left/right 
o ROR : rotate right 
o RRX : rotate right extended with C 
o MOV, MVN : move (negated) 

MOV rO, rl ; rO = rl 

MVN rO, rl ; rO = -rl 



ARM load/store instructions 
o LDR, LDRH, LDRB : load (half-word, byte) 
o STR, STRH, STRB : store (half-word, byte) 
o Addressing modes: 

• register indirect : LDR rO,[rl] 

o RO = MC[rl] 

• with second register : LDR r0,[rl,-r2] 

• with constant : LDR r0,[rl,#4] 



Exemple: Load and Store Word or Byte 



o The memory location to be accessed is held in a base register 

• STR rO, [rl] -> Store contents of rO to location pointed to by contents of rl 

• LDR r2, [rl] -> Load r2 with contents of memory location pointed to by contents 
of rl 



Source 
Register 
for STR 



rO 



0x5 



rl 



Base 
Register 



0x200 



Memory 



-^0x200 



0x5 




r2 



Destination 



0x5 | Register 



for LDR 



Exemples 1 & 2: C et ARM 



o EnC: 

x = (a + b) - c; 
o En Assembler 

ADR r4,a 

LDR r0,[r4] 

ADR r4,b 
r4 

LDRrl,[r4] 
ADD r3,r0,rl 
ADR r4,c 
LDR r2[r4] 
SUB r3,r3,r2 
ADR r4,x 
STR r3, [r4] 



ARM: 

; get address for a 

; get value of a 

; get address for b, reusing 



get value of b 
compute a+b 
get address for c 
get value of c 

complète computation of x 
get address for x 
store value of x 



o EnC: 

If (a==b) 
{ a++; } 
else 
{ a-; } 

o En Assembleur ARM: 

CMP R1,R2 /* a dans RI, b dansR2*/ 
ADDEQ Rl,#l /* si égale ajouter 1*/ 
SUBNE Rl,#l /* soustraire 1 si non */ 



O 



Exemple 3: IF 



o En C: 

if (a > b) { x = 5; y = c + d; } else x = c - d; 
o En Assembleur: 
; compute and test condition 



ADR r4,a 
LDR r0,[r4] 
ADR r4,b 
LDR rl,[r4] 
CMPrO,rl 
BGEfblock 
; true block 
MOV r0,#5 
ADR r4,x 
STR r0,[r4] 
ADR r4,c 
LDR r0,[r4] 
ADR r4,d 
LDR rl,[r4] 
ADD rO,rO,rl 
ADR r4,y 
STR r0,[r4] 
B after 



get address for a 
get value of a 
get address for b 
get value for b 
compare a < b 

if a >= b, branch to false block 

generate value for x 
get address for x 
store x 

get address for c 
get value of c 
get address for d 
get value of d 
compute y 
get address for y 
store y 

branch around false block 



, taise diock 






TDIOCK 


ADR r4,c 


; get address for c 




LDR r0,[r4] 


; get value of c 




ADR r4,d 


; get address for d 




LDR rl,[r4] 


; get value for d 




SUB rO,rO,rl ; compute c-d 




ADR r4,x 


; get address for x 




STR r0,[r4] 


; store value of x 


after ... 







Exemple 4 : Filtre FIR 

o 



EnC 

for (i=0, f=0; i<N; i++) 
f = f+c[i]*x[i]; 
o En Assembleur 
; loop initiation code 

MOV r0,#0 

MOV r8,#0 

ADR r2,N 

LDR rl,[r2] 

MOV r2,#0 

ADR r3,c 

ADR r5,x 
; loop body 
loop LDR r4,[r3,r8] 

LDR r6,[r5,r8] 

MULr4,r4,r6 

ADD r2,r2,r4 

ADD r8,r8,#4 

ADD rO,rO,#l 

CMP rO,rl 

BLT loop 



use rO for i 

use separate index for arrays 
get address for N 
get value of N 
use r2 for f 
load r3 with base of c 
load r5 with base of x 

; get c[i] 
; get x[i] 

; compute c[i]*x[i] 
; add into running sum 
; add one word offset to array index 
; add 1 to i 
; exit? 

; if i < N, continue